// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/api/proto/vizierconfigpb/vizier_types.proto

package vizierconfigpb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type VizierSpec struct {
	Version                  string                    `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	DeployKey                string                    `protobuf:"bytes,2,opt,name=deploy_key,json=deployKey,proto3" json:"deploy_key,omitempty"`
	DisableAutoUpdate        bool                      `protobuf:"varint,3,opt,name=disable_auto_update,json=disableAutoUpdate,proto3" json:"disable_auto_update,omitempty"`
	UseEtcdOperator          bool                      `protobuf:"varint,4,opt,name=use_etcd_operator,json=useEtcdOperator,proto3" json:"use_etcd_operator,omitempty"`
	ClusterName              string                    `protobuf:"bytes,5,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
	CloudAddr                string                    `protobuf:"bytes,6,opt,name=cloud_addr,json=cloudAddr,proto3" json:"cloud_addr,omitempty"`
	DevCloudNamespace        string                    `protobuf:"bytes,7,opt,name=dev_cloud_namespace,json=devCloudNamespace,proto3" json:"dev_cloud_namespace,omitempty"`
	PemMemoryLimit           string                    `protobuf:"bytes,8,opt,name=pem_memory_limit,json=pemMemoryLimit,proto3" json:"pem_memory_limit,omitempty"`
	PemMemoryRequest         string                    `protobuf:"bytes,17,opt,name=pem_memory_request,json=pemMemoryRequest,proto3" json:"pem_memory_request,omitempty"`
	Pod_Policy               *PodPolicyReq             `protobuf:"bytes,9,opt,name=Pod_Policy,json=PodPolicy,proto3" json:"Pod_Policy,omitempty"`
	Patches                  map[string]string         `protobuf:"bytes,10,rep,name=patches,proto3" json:"patches,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	ClockConverter           string                    `protobuf:"bytes,12,opt,name=clock_converter,json=clockConverter,proto3" json:"clock_converter,omitempty"`
	DataAccess               string                    `protobuf:"bytes,13,opt,name=data_access,json=dataAccess,proto3" json:"data_access,omitempty"`
	DataCollectorParams      *DataCollectorParams      `protobuf:"bytes,14,opt,name=data_collector_params,json=dataCollectorParams,proto3" json:"data_collector_params,omitempty"`
	LeadershipElectionParams *LeadershipElectionParams `protobuf:"bytes,15,opt,name=leadership_election_params,json=leadershipElectionParams,proto3" json:"leadership_election_params,omitempty"`
	CustomDeployKeySecret    string                    `protobuf:"bytes,16,opt,name=custom_deploy_key_secret,json=customDeployKeySecret,proto3" json:"custom_deploy_key_secret,omitempty"`
	Registry                 string                    `protobuf:"bytes,18,opt,name=registry,proto3" json:"registry,omitempty"`
	Autopilot                bool                      `protobuf:"varint,19,opt,name=autopilot,proto3" json:"autopilot,omitempty"`
}

func (m *VizierSpec) Reset()      { *m = VizierSpec{} }
func (*VizierSpec) ProtoMessage() {}
func (*VizierSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_5892195818dca4ca, []int{0}
}
func (m *VizierSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VizierSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_VizierSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *VizierSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VizierSpec.Merge(m, src)
}
func (m *VizierSpec) XXX_Size() int {
	return m.Size()
}
func (m *VizierSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_VizierSpec.DiscardUnknown(m)
}

var xxx_messageInfo_VizierSpec proto.InternalMessageInfo

func (m *VizierSpec) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *VizierSpec) GetDeployKey() string {
	if m != nil {
		return m.DeployKey
	}
	return ""
}

func (m *VizierSpec) GetDisableAutoUpdate() bool {
	if m != nil {
		return m.DisableAutoUpdate
	}
	return false
}

func (m *VizierSpec) GetUseEtcdOperator() bool {
	if m != nil {
		return m.UseEtcdOperator
	}
	return false
}

func (m *VizierSpec) GetClusterName() string {
	if m != nil {
		return m.ClusterName
	}
	return ""
}

func (m *VizierSpec) GetCloudAddr() string {
	if m != nil {
		return m.CloudAddr
	}
	return ""
}

func (m *VizierSpec) GetDevCloudNamespace() string {
	if m != nil {
		return m.DevCloudNamespace
	}
	return ""
}

func (m *VizierSpec) GetPemMemoryLimit() string {
	if m != nil {
		return m.PemMemoryLimit
	}
	return ""
}

func (m *VizierSpec) GetPemMemoryRequest() string {
	if m != nil {
		return m.PemMemoryRequest
	}
	return ""
}

func (m *VizierSpec) GetPod_Policy() *PodPolicyReq {
	if m != nil {
		return m.Pod_Policy
	}
	return nil
}

func (m *VizierSpec) GetPatches() map[string]string {
	if m != nil {
		return m.Patches
	}
	return nil
}

func (m *VizierSpec) GetClockConverter() string {
	if m != nil {
		return m.ClockConverter
	}
	return ""
}

func (m *VizierSpec) GetDataAccess() string {
	if m != nil {
		return m.DataAccess
	}
	return ""
}

func (m *VizierSpec) GetDataCollectorParams() *DataCollectorParams {
	if m != nil {
		return m.DataCollectorParams
	}
	return nil
}

func (m *VizierSpec) GetLeadershipElectionParams() *LeadershipElectionParams {
	if m != nil {
		return m.LeadershipElectionParams
	}
	return nil
}

func (m *VizierSpec) GetCustomDeployKeySecret() string {
	if m != nil {
		return m.CustomDeployKeySecret
	}
	return ""
}

func (m *VizierSpec) GetRegistry() string {
	if m != nil {
		return m.Registry
	}
	return ""
}

func (m *VizierSpec) GetAutopilot() bool {
	if m != nil {
		return m.Autopilot
	}
	return false
}

type PodPolicyReq struct {
	Labels       map[string]string `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Annotations  map[string]string `protobuf:"bytes,2,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Resources    *ResourceReqs     `protobuf:"bytes,3,opt,name=resources,proto3" json:"resources,omitempty"`
	NodeSelector map[string]string `protobuf:"bytes,4,rep,name=nodeSelector,proto3" json:"nodeSelector,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Tolerations  []*Toleration     `protobuf:"bytes,5,rep,name=tolerations,proto3" json:"tolerations,omitempty"`
}

func (m *PodPolicyReq) Reset()      { *m = PodPolicyReq{} }
func (*PodPolicyReq) ProtoMessage() {}
func (*PodPolicyReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_5892195818dca4ca, []int{1}
}
func (m *PodPolicyReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PodPolicyReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PodPolicyReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PodPolicyReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PodPolicyReq.Merge(m, src)
}
func (m *PodPolicyReq) XXX_Size() int {
	return m.Size()
}
func (m *PodPolicyReq) XXX_DiscardUnknown() {
	xxx_messageInfo_PodPolicyReq.DiscardUnknown(m)
}

var xxx_messageInfo_PodPolicyReq proto.InternalMessageInfo

func (m *PodPolicyReq) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *PodPolicyReq) GetAnnotations() map[string]string {
	if m != nil {
		return m.Annotations
	}
	return nil
}

func (m *PodPolicyReq) GetResources() *ResourceReqs {
	if m != nil {
		return m.Resources
	}
	return nil
}

func (m *PodPolicyReq) GetNodeSelector() map[string]string {
	if m != nil {
		return m.NodeSelector
	}
	return nil
}

func (m *PodPolicyReq) GetTolerations() []*Toleration {
	if m != nil {
		return m.Tolerations
	}
	return nil
}

type ResourceReqs struct {
	Limits   *ResourceList `protobuf:"bytes,1,opt,name=limits,proto3" json:"limits,omitempty"`
	Requests *ResourceList `protobuf:"bytes,2,opt,name=requests,proto3" json:"requests,omitempty"`
}

func (m *ResourceReqs) Reset()      { *m = ResourceReqs{} }
func (*ResourceReqs) ProtoMessage() {}
func (*ResourceReqs) Descriptor() ([]byte, []int) {
	return fileDescriptor_5892195818dca4ca, []int{2}
}
func (m *ResourceReqs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ResourceReqs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ResourceReqs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ResourceReqs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResourceReqs.Merge(m, src)
}
func (m *ResourceReqs) XXX_Size() int {
	return m.Size()
}
func (m *ResourceReqs) XXX_DiscardUnknown() {
	xxx_messageInfo_ResourceReqs.DiscardUnknown(m)
}

var xxx_messageInfo_ResourceReqs proto.InternalMessageInfo

func (m *ResourceReqs) GetLimits() *ResourceList {
	if m != nil {
		return m.Limits
	}
	return nil
}

func (m *ResourceReqs) GetRequests() *ResourceList {
	if m != nil {
		return m.Requests
	}
	return nil
}

type Toleration struct {
	Key               string            `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Operator          string            `protobuf:"bytes,2,opt,name=operator,proto3" json:"operator,omitempty"`
	Value             string            `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	Effect            string            `protobuf:"bytes,4,opt,name=effect,proto3" json:"effect,omitempty"`
	TolerationSeconds *types.Int64Value `protobuf:"bytes,5,opt,name=toleration_seconds,json=tolerationSeconds,proto3" json:"toleration_seconds,omitempty"`
}

func (m *Toleration) Reset()      { *m = Toleration{} }
func (*Toleration) ProtoMessage() {}
func (*Toleration) Descriptor() ([]byte, []int) {
	return fileDescriptor_5892195818dca4ca, []int{3}
}
func (m *Toleration) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Toleration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Toleration.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Toleration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Toleration.Merge(m, src)
}
func (m *Toleration) XXX_Size() int {
	return m.Size()
}
func (m *Toleration) XXX_DiscardUnknown() {
	xxx_messageInfo_Toleration.DiscardUnknown(m)
}

var xxx_messageInfo_Toleration proto.InternalMessageInfo

func (m *Toleration) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *Toleration) GetOperator() string {
	if m != nil {
		return m.Operator
	}
	return ""
}

func (m *Toleration) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (m *Toleration) GetEffect() string {
	if m != nil {
		return m.Effect
	}
	return ""
}

func (m *Toleration) GetTolerationSeconds() *types.Int64Value {
	if m != nil {
		return m.TolerationSeconds
	}
	return nil
}

type ResourceList struct {
	ResourceList map[string]*ResourceQuantity `protobuf:"bytes,1,rep,name=resource_list,json=resourceList,proto3" json:"resource_list,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *ResourceList) Reset()      { *m = ResourceList{} }
func (*ResourceList) ProtoMessage() {}
func (*ResourceList) Descriptor() ([]byte, []int) {
	return fileDescriptor_5892195818dca4ca, []int{4}
}
func (m *ResourceList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ResourceList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ResourceList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ResourceList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResourceList.Merge(m, src)
}
func (m *ResourceList) XXX_Size() int {
	return m.Size()
}
func (m *ResourceList) XXX_DiscardUnknown() {
	xxx_messageInfo_ResourceList.DiscardUnknown(m)
}

var xxx_messageInfo_ResourceList proto.InternalMessageInfo

func (m *ResourceList) GetResourceList() map[string]*ResourceQuantity {
	if m != nil {
		return m.ResourceList
	}
	return nil
}

type ResourceQuantity struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *ResourceQuantity) Reset()      { *m = ResourceQuantity{} }
func (*ResourceQuantity) ProtoMessage() {}
func (*ResourceQuantity) Descriptor() ([]byte, []int) {
	return fileDescriptor_5892195818dca4ca, []int{5}
}
func (m *ResourceQuantity) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ResourceQuantity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ResourceQuantity.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ResourceQuantity) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResourceQuantity.Merge(m, src)
}
func (m *ResourceQuantity) XXX_Size() int {
	return m.Size()
}
func (m *ResourceQuantity) XXX_DiscardUnknown() {
	xxx_messageInfo_ResourceQuantity.DiscardUnknown(m)
}

var xxx_messageInfo_ResourceQuantity proto.InternalMessageInfo

func (m *ResourceQuantity) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type DataCollectorParams struct {
	DatastreamBufferSize      uint32            `protobuf:"varint,1,opt,name=datastream_buffer_size,json=datastreamBufferSize,proto3" json:"datastream_buffer_size,omitempty"`
	DatastreamBufferSpikeSize uint32            `protobuf:"varint,2,opt,name=datastream_buffer_spike_size,json=datastreamBufferSpikeSize,proto3" json:"datastream_buffer_spike_size,omitempty"`
	CustomPEMFlags            map[string]string `protobuf:"bytes,4,rep,name=custom_pem_flags,json=customPemFlags,proto3" json:"custom_pem_flags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *DataCollectorParams) Reset()      { *m = DataCollectorParams{} }
func (*DataCollectorParams) ProtoMessage() {}
func (*DataCollectorParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_5892195818dca4ca, []int{6}
}
func (m *DataCollectorParams) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DataCollectorParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DataCollectorParams.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DataCollectorParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DataCollectorParams.Merge(m, src)
}
func (m *DataCollectorParams) XXX_Size() int {
	return m.Size()
}
func (m *DataCollectorParams) XXX_DiscardUnknown() {
	xxx_messageInfo_DataCollectorParams.DiscardUnknown(m)
}

var xxx_messageInfo_DataCollectorParams proto.InternalMessageInfo

func (m *DataCollectorParams) GetDatastreamBufferSize() uint32 {
	if m != nil {
		return m.DatastreamBufferSize
	}
	return 0
}

func (m *DataCollectorParams) GetDatastreamBufferSpikeSize() uint32 {
	if m != nil {
		return m.DatastreamBufferSpikeSize
	}
	return 0
}

func (m *DataCollectorParams) GetCustomPEMFlags() map[string]string {
	if m != nil {
		return m.CustomPEMFlags
	}
	return nil
}

type LeadershipElectionParams struct {
	ElectionPeriodMs int64 `protobuf:"varint,1,opt,name=election_period_ms,json=electionPeriodMs,proto3" json:"election_period_ms,omitempty"`
}

func (m *LeadershipElectionParams) Reset()      { *m = LeadershipElectionParams{} }
func (*LeadershipElectionParams) ProtoMessage() {}
func (*LeadershipElectionParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_5892195818dca4ca, []int{7}
}
func (m *LeadershipElectionParams) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LeadershipElectionParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LeadershipElectionParams.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LeadershipElectionParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LeadershipElectionParams.Merge(m, src)
}
func (m *LeadershipElectionParams) XXX_Size() int {
	return m.Size()
}
func (m *LeadershipElectionParams) XXX_DiscardUnknown() {
	xxx_messageInfo_LeadershipElectionParams.DiscardUnknown(m)
}

var xxx_messageInfo_LeadershipElectionParams proto.InternalMessageInfo

func (m *LeadershipElectionParams) GetElectionPeriodMs() int64 {
	if m != nil {
		return m.ElectionPeriodMs
	}
	return 0
}

func init() {
	proto.RegisterType((*VizierSpec)(nil), "px.vizierconfigpb.VizierSpec")
	proto.RegisterMapType((map[string]string)(nil), "px.vizierconfigpb.VizierSpec.PatchesEntry")
	proto.RegisterType((*PodPolicyReq)(nil), "px.vizierconfigpb.PodPolicyReq")
	proto.RegisterMapType((map[string]string)(nil), "px.vizierconfigpb.PodPolicyReq.AnnotationsEntry")
	proto.RegisterMapType((map[string]string)(nil), "px.vizierconfigpb.PodPolicyReq.LabelsEntry")
	proto.RegisterMapType((map[string]string)(nil), "px.vizierconfigpb.PodPolicyReq.NodeSelectorEntry")
	proto.RegisterType((*ResourceReqs)(nil), "px.vizierconfigpb.ResourceReqs")
	proto.RegisterType((*Toleration)(nil), "px.vizierconfigpb.Toleration")
	proto.RegisterType((*ResourceList)(nil), "px.vizierconfigpb.ResourceList")
	proto.RegisterMapType((map[string]*ResourceQuantity)(nil), "px.vizierconfigpb.ResourceList.ResourceListEntry")
	proto.RegisterType((*ResourceQuantity)(nil), "px.vizierconfigpb.ResourceQuantity")
	proto.RegisterType((*DataCollectorParams)(nil), "px.vizierconfigpb.DataCollectorParams")
	proto.RegisterMapType((map[string]string)(nil), "px.vizierconfigpb.DataCollectorParams.CustomPemFlagsEntry")
	proto.RegisterType((*LeadershipElectionParams)(nil), "px.vizierconfigpb.LeadershipElectionParams")
}

func init() {
	proto.RegisterFile("src/api/proto/vizierconfigpb/vizier_types.proto", fileDescriptor_5892195818dca4ca)
}

var fileDescriptor_5892195818dca4ca = []byte{
	// 1167 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x4f, 0x73, 0xd3, 0x46,
	0x14, 0x8f, 0xe2, 0x90, 0xc4, 0xcf, 0x26, 0xd8, 0x1b, 0x60, 0xb6, 0x2e, 0x88, 0xd4, 0x9d, 0x69,
	0x3d, 0xd0, 0x2a, 0x25, 0x65, 0x4a, 0xa1, 0x53, 0x98, 0x90, 0xa4, 0xd3, 0xd2, 0x40, 0x5d, 0xa5,
	0x70, 0xe0, 0xa2, 0x59, 0x4b, 0xcf, 0x46, 0x83, 0xa4, 0x15, 0xbb, 0x2b, 0x17, 0x73, 0xea, 0xa1,
	0x1f, 0xa0, 0x1f, 0xa3, 0x1f, 0xa0, 0x33, 0x9d, 0xe9, 0x27, 0xe8, 0xa1, 0x33, 0xe5, 0xc8, 0xa9,
	0x53, 0x9c, 0x4b, 0x8f, 0x7c, 0x84, 0x8e, 0x56, 0xb2, 0xa5, 0x10, 0x43, 0xc8, 0x4d, 0xfb, 0xde,
	0xef, 0xf7, 0xde, 0xbe, 0xb7, 0xef, 0x8f, 0x60, 0x5d, 0x0a, 0x77, 0x9d, 0xc5, 0xfe, 0x7a, 0x2c,
	0xb8, 0xe2, 0xeb, 0x43, 0xff, 0xa9, 0x8f, 0xc2, 0xe5, 0x51, 0xdf, 0x1f, 0xc4, 0xbd, 0xfc, 0xe8,
	0xa8, 0x51, 0x8c, 0xd2, 0xd2, 0x08, 0xd2, 0x8c, 0x9f, 0x58, 0x07, 0x51, 0xad, 0x8f, 0x07, 0xbe,
	0x7a, 0x98, 0xf4, 0x2c, 0x97, 0x87, 0xeb, 0x03, 0x3e, 0xe0, 0x99, 0xad, 0x5e, 0xd2, 0xd7, 0xa7,
	0xcc, 0x70, 0xfa, 0x95, 0x59, 0x68, 0x99, 0x03, 0xce, 0x07, 0x01, 0x16, 0xa8, 0x1f, 0x05, 0x8b,
	0x63, 0x14, 0xb9, 0x87, 0xf6, 0xef, 0x4b, 0x00, 0xf7, 0xb5, 0x87, 0xbd, 0x18, 0x5d, 0x42, 0x61,
	0x69, 0x88, 0x42, 0xfa, 0x3c, 0xa2, 0xc6, 0x9a, 0xd1, 0xa9, 0xda, 0x93, 0x23, 0x39, 0x0f, 0xe0,
	0x61, 0x1c, 0xf0, 0x91, 0xf3, 0x08, 0x47, 0x74, 0x5e, 0x2b, 0xab, 0x99, 0xe4, 0x5b, 0x1c, 0x11,
	0x0b, 0x56, 0x3d, 0x5f, 0xb2, 0x5e, 0x80, 0x0e, 0x4b, 0x14, 0x77, 0x92, 0xd8, 0x63, 0x0a, 0x69,
	0x65, 0xcd, 0xe8, 0x2c, 0xdb, 0xcd, 0x5c, 0xb5, 0x99, 0x28, 0x7e, 0x4f, 0x2b, 0xc8, 0x45, 0x68,
	0x26, 0x12, 0x1d, 0x54, 0xae, 0xe7, 0xf0, 0x18, 0x05, 0x53, 0x5c, 0xd0, 0x05, 0x8d, 0x3e, 0x95,
	0x48, 0xdc, 0x51, 0xae, 0xf7, 0x5d, 0x2e, 0x26, 0xef, 0x41, 0xdd, 0x0d, 0x12, 0xa9, 0x50, 0x38,
	0x11, 0x0b, 0x91, 0x9e, 0xd0, 0xce, 0x6b, 0xb9, 0xec, 0x2e, 0x0b, 0x31, 0xbd, 0x9d, 0x1b, 0xf0,
	0xc4, 0x73, 0x98, 0xe7, 0x09, 0xba, 0x98, 0xdd, 0x4e, 0x4b, 0x36, 0x3d, 0x4f, 0xe8, 0xdb, 0xe1,
	0xd0, 0xc9, 0x20, 0xa9, 0x0d, 0x19, 0x33, 0x17, 0xe9, 0x92, 0xc6, 0x35, 0x3d, 0x1c, 0x6e, 0xa5,
	0x9a, 0xbb, 0x13, 0x05, 0xe9, 0x40, 0x23, 0xc6, 0xd0, 0x09, 0x31, 0xe4, 0x62, 0xe4, 0x04, 0x7e,
	0xe8, 0x2b, 0xba, 0xac, 0xc1, 0x2b, 0x31, 0x86, 0x77, 0xb4, 0x78, 0x37, 0x95, 0x92, 0x8f, 0x80,
	0x94, 0x90, 0x02, 0x1f, 0x27, 0x28, 0x15, 0x6d, 0x6a, 0x6c, 0x63, 0x8a, 0xb5, 0x33, 0x39, 0xb9,
	0x01, 0xd0, 0xe5, 0x9e, 0xd3, 0xe5, 0x81, 0xef, 0x8e, 0x68, 0x75, 0xcd, 0xe8, 0xd4, 0x36, 0x2e,
	0x58, 0x87, 0x1e, 0xd9, 0xea, 0x72, 0x2f, 0xc3, 0xd8, 0xf8, 0xd8, 0xae, 0x4e, 0x4f, 0x64, 0x1b,
	0x96, 0x62, 0xa6, 0xdc, 0x87, 0x28, 0x29, 0xac, 0x55, 0x3a, 0xb5, 0x8d, 0x8b, 0x33, 0xc8, 0xc5,
	0x73, 0x5a, 0xdd, 0x0c, 0xbc, 0x13, 0x29, 0x31, 0xb2, 0x27, 0x54, 0xf2, 0x21, 0x9c, 0x72, 0x03,
	0xee, 0x3e, 0x72, 0x5c, 0x1e, 0x0d, 0x51, 0x28, 0x14, 0xb4, 0x9e, 0x05, 0xa7, 0xc5, 0x5b, 0x13,
	0x29, 0xb9, 0x00, 0x35, 0x8f, 0x29, 0xe6, 0x30, 0xd7, 0x45, 0x29, 0xe9, 0x49, 0x0d, 0x82, 0x54,
	0xb4, 0xa9, 0x25, 0xe4, 0x01, 0x9c, 0xd1, 0x00, 0x97, 0x07, 0x01, 0xba, 0x8a, 0x0b, 0x27, 0x66,
	0x82, 0x85, 0x92, 0xae, 0xe8, 0xd0, 0x3e, 0x98, 0x71, 0xbb, 0x6d, 0xa6, 0xd8, 0xd6, 0x04, 0xde,
	0xd5, 0x68, 0x7b, 0xd5, 0x3b, 0x2c, 0x24, 0x3e, 0xb4, 0x02, 0x64, 0x1e, 0x0a, 0xf9, 0xd0, 0x8f,
	0x1d, 0x4c, 0x75, 0x3e, 0x8f, 0x26, 0x0e, 0x4e, 0x69, 0x07, 0x97, 0x66, 0x38, 0xd8, 0x9d, 0x92,
	0x76, 0x72, 0x4e, 0xee, 0x85, 0x06, 0xaf, 0xd1, 0x90, 0xab, 0x40, 0xdd, 0x44, 0x2a, 0x1e, 0x3a,
	0x45, 0x89, 0x3b, 0x12, 0x5d, 0x81, 0x8a, 0x36, 0x74, 0xd0, 0x67, 0x32, 0xfd, 0xf6, 0xa4, 0xde,
	0xf7, 0xb4, 0x92, 0xb4, 0x60, 0x59, 0xe0, 0xc0, 0x97, 0x4a, 0x8c, 0x28, 0xd1, 0xc0, 0xe9, 0x99,
	0x9c, 0x83, 0x6a, 0xda, 0x09, 0xb1, 0x1f, 0x70, 0x45, 0x57, 0x75, 0x65, 0x17, 0x82, 0xd6, 0x75,
	0xa8, 0x97, 0x1f, 0x87, 0x34, 0xa0, 0x92, 0xf6, 0x55, 0xd6, 0x74, 0xe9, 0x27, 0x39, 0x0d, 0x27,
	0x86, 0x2c, 0x48, 0x30, 0xef, 0xb5, 0xec, 0x70, 0x7d, 0xfe, 0x73, 0xe3, 0xf6, 0xc2, 0x72, 0xad,
	0x51, 0x6f, 0xff, 0xb1, 0x00, 0xf5, 0x72, 0x9d, 0x90, 0x2d, 0x58, 0x0c, 0x58, 0x0f, 0x03, 0x49,
	0x0d, 0x5d, 0x1b, 0x97, 0x8e, 0x28, 0x2c, 0x6b, 0x57, 0xa3, 0xb3, 0xe2, 0xc8, 0xa9, 0xc4, 0x86,
	0x1a, 0x8b, 0x22, 0xae, 0x58, 0x9a, 0x1e, 0x49, 0xe7, 0xb5, 0xa5, 0x4f, 0x8e, 0xb2, 0xb4, 0x59,
	0x50, 0x32, 0x73, 0x65, 0x23, 0xe4, 0x4b, 0xa8, 0x0a, 0x94, 0x3c, 0x11, 0x2e, 0x4a, 0x3d, 0x11,
	0x66, 0x17, 0xbd, 0x9d, 0x63, 0x6c, 0x7c, 0x2c, 0xed, 0x82, 0x41, 0xee, 0x41, 0x3d, 0xe2, 0x1e,
	0xee, 0x61, 0x56, 0x1e, 0x74, 0x41, 0xdf, 0xe9, 0xf2, 0x51, 0x77, 0xba, 0x5b, 0xe2, 0x64, 0x97,
	0x3a, 0x60, 0x86, 0xdc, 0x84, 0x9a, 0xe2, 0x41, 0x3a, 0x62, 0x74, 0xa4, 0x27, 0xb4, 0xd5, 0xf3,
	0x33, 0xac, 0xfe, 0x30, 0x45, 0xd9, 0x65, 0x46, 0xeb, 0x1a, 0xd4, 0x4a, 0x19, 0x3c, 0xce, 0x0b,
	0xb6, 0x6e, 0x40, 0xe3, 0xd5, 0x94, 0x1d, 0x8b, 0x7f, 0x13, 0x9a, 0x87, 0xc2, 0x3b, 0x8e, 0x81,
	0xf6, 0xcf, 0x06, 0xd4, 0xcb, 0xf9, 0x26, 0x57, 0x61, 0x51, 0x8f, 0x39, 0xa9, 0xf9, 0x6f, 0x7e,
	0xa0, 0x5d, 0x5f, 0x2a, 0x3b, 0x87, 0x93, 0x2f, 0xd2, 0x16, 0xd0, 0xd3, 0x4d, 0x6a, 0x37, 0x6f,
	0x41, 0x9d, 0x12, 0xda, 0xbf, 0x19, 0x00, 0x45, 0x7a, 0x67, 0x44, 0xd0, 0x82, 0xe5, 0xe9, 0x76,
	0xc8, 0x82, 0x98, 0x9e, 0x8b, 0xe8, 0x2a, 0xa5, 0xe8, 0xc8, 0x59, 0x58, 0xc4, 0x7e, 0x1f, 0x5d,
	0xa5, 0xb7, 0x49, 0xd5, 0xce, 0x4f, 0xe4, 0x36, 0x90, 0xe2, 0xf1, 0xd2, 0xe6, 0xe6, 0x91, 0x27,
	0xf5, 0x2a, 0xa9, 0x6d, 0xbc, 0x6b, 0x65, 0x5b, 0xd2, 0x9a, 0x6c, 0x49, 0xeb, 0x9b, 0x48, 0x7d,
	0x76, 0xe5, 0x7e, 0x6a, 0xd0, 0x6e, 0x16, 0xb4, 0xbd, 0x8c, 0xd5, 0xfe, 0xab, 0x94, 0xbd, 0x34,
	0x22, 0x72, 0x1f, 0x4e, 0x4e, 0xea, 0xd5, 0x09, 0x7c, 0xa9, 0xf2, 0x0e, 0xbc, 0x7c, 0x44, 0x26,
	0x0e, 0x1c, 0xf2, 0x1a, 0x15, 0x25, 0x51, 0xcb, 0x83, 0xe6, 0x21, 0xc8, 0x8c, 0x2c, 0x5d, 0x2b,
	0xbf, 0x73, 0x6d, 0xe3, 0xfd, 0x37, 0xb8, 0xfd, 0x3e, 0x61, 0x91, 0xf2, 0xd5, 0xa8, 0x5c, 0x0c,
	0x1d, 0x68, 0xbc, 0xaa, 0x2e, 0x92, 0x6b, 0x94, 0x92, 0xdb, 0xfe, 0x7b, 0x1e, 0x56, 0x67, 0x0c,
	0x70, 0x72, 0x05, 0xce, 0xa6, 0x23, 0x5c, 0x2a, 0x81, 0x2c, 0x74, 0x7a, 0x49, 0xbf, 0x8f, 0xc2,
	0x91, 0xfe, 0xd3, 0x8c, 0x7e, 0xd2, 0x3e, 0x5d, 0x68, 0x6f, 0x69, 0xe5, 0x9e, 0xff, 0x14, 0xc9,
	0x4d, 0x38, 0x37, 0x83, 0x15, 0xfb, 0x8f, 0x30, 0xe3, 0xce, 0x6b, 0xee, 0x3b, 0x87, 0xb8, 0x29,
	0x42, 0x1b, 0x78, 0x02, 0x8d, 0x7c, 0x6e, 0xa7, 0x3b, 0xb8, 0x1f, 0xb0, 0x81, 0xcc, 0xa7, 0xc3,
	0xf5, 0xb7, 0xdb, 0x3c, 0xd6, 0x96, 0xa6, 0x77, 0x31, 0xfc, 0x2a, 0x25, 0xeb, 0xfc, 0xde, 0x22,
	0xe3, 0x7f, 0x2e, 0xac, 0xe4, 0x8a, 0x9d, 0x3b, 0x5a, 0x61, 0xaf, 0xb8, 0x07, 0x80, 0xad, 0x4d,
	0x58, 0x9d, 0x41, 0x3d, 0xe6, 0x14, 0xaf, 0x34, 0x16, 0xda, 0x5f, 0x03, 0x7d, 0xdd, 0xc2, 0x4a,
	0xff, 0x2d, 0x8a, 0xb5, 0x87, 0xc2, 0xe7, 0x9e, 0x13, 0x66, 0xfd, 0x59, 0xb1, 0x1b, 0x13, 0x4d,
	0x57, 0x2b, 0xee, 0xc8, 0x5b, 0xdb, 0xcf, 0x5e, 0x98, 0x73, 0xcf, 0x5f, 0x98, 0x73, 0x2f, 0x5f,
	0x98, 0xc6, 0x4f, 0x63, 0xd3, 0xf8, 0x75, 0x6c, 0x1a, 0x7f, 0x8e, 0x4d, 0xe3, 0xd9, 0xd8, 0x34,
	0xfe, 0x1d, 0x9b, 0xc6, 0x7f, 0x63, 0x73, 0xee, 0xe5, 0xd8, 0x34, 0x7e, 0xd9, 0x37, 0xe7, 0x9e,
	0xed, 0x9b, 0x73, 0xcf, 0xf7, 0xcd, 0xb9, 0x07, 0x2b, 0x07, 0x93, 0xd4, 0x5b, 0xd4, 0x2d, 0xf0,
	0xe9, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x5b, 0x21, 0x56, 0xab, 0x0a, 0x00, 0x00,
}

func (this *VizierSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierSpec)
	if !ok {
		that2, ok := that.(VizierSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Version != that1.Version {
		return false
	}
	if this.DeployKey != that1.DeployKey {
		return false
	}
	if this.DisableAutoUpdate != that1.DisableAutoUpdate {
		return false
	}
	if this.UseEtcdOperator != that1.UseEtcdOperator {
		return false
	}
	if this.ClusterName != that1.ClusterName {
		return false
	}
	if this.CloudAddr != that1.CloudAddr {
		return false
	}
	if this.DevCloudNamespace != that1.DevCloudNamespace {
		return false
	}
	if this.PemMemoryLimit != that1.PemMemoryLimit {
		return false
	}
	if this.PemMemoryRequest != that1.PemMemoryRequest {
		return false
	}
	if !this.Pod_Policy.Equal(that1.Pod_Policy) {
		return false
	}
	if len(this.Patches) != len(that1.Patches) {
		return false
	}
	for i := range this.Patches {
		if this.Patches[i] != that1.Patches[i] {
			return false
		}
	}
	if this.ClockConverter != that1.ClockConverter {
		return false
	}
	if this.DataAccess != that1.DataAccess {
		return false
	}
	if !this.DataCollectorParams.Equal(that1.DataCollectorParams) {
		return false
	}
	if !this.LeadershipElectionParams.Equal(that1.LeadershipElectionParams) {
		return false
	}
	if this.CustomDeployKeySecret != that1.CustomDeployKeySecret {
		return false
	}
	if this.Registry != that1.Registry {
		return false
	}
	if this.Autopilot != that1.Autopilot {
		return false
	}
	return true
}
func (this *PodPolicyReq) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PodPolicyReq)
	if !ok {
		that2, ok := that.(PodPolicyReq)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Labels) != len(that1.Labels) {
		return false
	}
	for i := range this.Labels {
		if this.Labels[i] != that1.Labels[i] {
			return false
		}
	}
	if len(this.Annotations) != len(that1.Annotations) {
		return false
	}
	for i := range this.Annotations {
		if this.Annotations[i] != that1.Annotations[i] {
			return false
		}
	}
	if !this.Resources.Equal(that1.Resources) {
		return false
	}
	if len(this.NodeSelector) != len(that1.NodeSelector) {
		return false
	}
	for i := range this.NodeSelector {
		if this.NodeSelector[i] != that1.NodeSelector[i] {
			return false
		}
	}
	if len(this.Tolerations) != len(that1.Tolerations) {
		return false
	}
	for i := range this.Tolerations {
		if !this.Tolerations[i].Equal(that1.Tolerations[i]) {
			return false
		}
	}
	return true
}
func (this *ResourceReqs) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceReqs)
	if !ok {
		that2, ok := that.(ResourceReqs)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Limits.Equal(that1.Limits) {
		return false
	}
	if !this.Requests.Equal(that1.Requests) {
		return false
	}
	return true
}
func (this *Toleration) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Toleration)
	if !ok {
		that2, ok := that.(Toleration)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if this.Operator != that1.Operator {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	if this.Effect != that1.Effect {
		return false
	}
	if !this.TolerationSeconds.Equal(that1.TolerationSeconds) {
		return false
	}
	return true
}
func (this *ResourceList) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceList)
	if !ok {
		that2, ok := that.(ResourceList)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.ResourceList) != len(that1.ResourceList) {
		return false
	}
	for i := range this.ResourceList {
		if !this.ResourceList[i].Equal(that1.ResourceList[i]) {
			return false
		}
	}
	return true
}
func (this *ResourceQuantity) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceQuantity)
	if !ok {
		that2, ok := that.(ResourceQuantity)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	return true
}
func (this *DataCollectorParams) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DataCollectorParams)
	if !ok {
		that2, ok := that.(DataCollectorParams)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DatastreamBufferSize != that1.DatastreamBufferSize {
		return false
	}
	if this.DatastreamBufferSpikeSize != that1.DatastreamBufferSpikeSize {
		return false
	}
	if len(this.CustomPEMFlags) != len(that1.CustomPEMFlags) {
		return false
	}
	for i := range this.CustomPEMFlags {
		if this.CustomPEMFlags[i] != that1.CustomPEMFlags[i] {
			return false
		}
	}
	return true
}
func (this *LeadershipElectionParams) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LeadershipElectionParams)
	if !ok {
		that2, ok := that.(LeadershipElectionParams)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ElectionPeriodMs != that1.ElectionPeriodMs {
		return false
	}
	return true
}
func (this *VizierSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 22)
	s = append(s, "&vizierconfigpb.VizierSpec{")
	s = append(s, "Version: "+fmt.Sprintf("%#v", this.Version)+",\n")
	s = append(s, "DeployKey: "+fmt.Sprintf("%#v", this.DeployKey)+",\n")
	s = append(s, "DisableAutoUpdate: "+fmt.Sprintf("%#v", this.DisableAutoUpdate)+",\n")
	s = append(s, "UseEtcdOperator: "+fmt.Sprintf("%#v", this.UseEtcdOperator)+",\n")
	s = append(s, "ClusterName: "+fmt.Sprintf("%#v", this.ClusterName)+",\n")
	s = append(s, "CloudAddr: "+fmt.Sprintf("%#v", this.CloudAddr)+",\n")
	s = append(s, "DevCloudNamespace: "+fmt.Sprintf("%#v", this.DevCloudNamespace)+",\n")
	s = append(s, "PemMemoryLimit: "+fmt.Sprintf("%#v", this.PemMemoryLimit)+",\n")
	s = append(s, "PemMemoryRequest: "+fmt.Sprintf("%#v", this.PemMemoryRequest)+",\n")
	if this.Pod_Policy != nil {
		s = append(s, "Pod_Policy: "+fmt.Sprintf("%#v", this.Pod_Policy)+",\n")
	}
	keysForPatches := make([]string, 0, len(this.Patches))
	for k, _ := range this.Patches {
		keysForPatches = append(keysForPatches, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForPatches)
	mapStringForPatches := "map[string]string{"
	for _, k := range keysForPatches {
		mapStringForPatches += fmt.Sprintf("%#v: %#v,", k, this.Patches[k])
	}
	mapStringForPatches += "}"
	if this.Patches != nil {
		s = append(s, "Patches: "+mapStringForPatches+",\n")
	}
	s = append(s, "ClockConverter: "+fmt.Sprintf("%#v", this.ClockConverter)+",\n")
	s = append(s, "DataAccess: "+fmt.Sprintf("%#v", this.DataAccess)+",\n")
	if this.DataCollectorParams != nil {
		s = append(s, "DataCollectorParams: "+fmt.Sprintf("%#v", this.DataCollectorParams)+",\n")
	}
	if this.LeadershipElectionParams != nil {
		s = append(s, "LeadershipElectionParams: "+fmt.Sprintf("%#v", this.LeadershipElectionParams)+",\n")
	}
	s = append(s, "CustomDeployKeySecret: "+fmt.Sprintf("%#v", this.CustomDeployKeySecret)+",\n")
	s = append(s, "Registry: "+fmt.Sprintf("%#v", this.Registry)+",\n")
	s = append(s, "Autopilot: "+fmt.Sprintf("%#v", this.Autopilot)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PodPolicyReq) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&vizierconfigpb.PodPolicyReq{")
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%#v: %#v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	if this.Labels != nil {
		s = append(s, "Labels: "+mapStringForLabels+",\n")
	}
	keysForAnnotations := make([]string, 0, len(this.Annotations))
	for k, _ := range this.Annotations {
		keysForAnnotations = append(keysForAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
	mapStringForAnnotations := "map[string]string{"
	for _, k := range keysForAnnotations {
		mapStringForAnnotations += fmt.Sprintf("%#v: %#v,", k, this.Annotations[k])
	}
	mapStringForAnnotations += "}"
	if this.Annotations != nil {
		s = append(s, "Annotations: "+mapStringForAnnotations+",\n")
	}
	if this.Resources != nil {
		s = append(s, "Resources: "+fmt.Sprintf("%#v", this.Resources)+",\n")
	}
	keysForNodeSelector := make([]string, 0, len(this.NodeSelector))
	for k, _ := range this.NodeSelector {
		keysForNodeSelector = append(keysForNodeSelector, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
	mapStringForNodeSelector := "map[string]string{"
	for _, k := range keysForNodeSelector {
		mapStringForNodeSelector += fmt.Sprintf("%#v: %#v,", k, this.NodeSelector[k])
	}
	mapStringForNodeSelector += "}"
	if this.NodeSelector != nil {
		s = append(s, "NodeSelector: "+mapStringForNodeSelector+",\n")
	}
	if this.Tolerations != nil {
		s = append(s, "Tolerations: "+fmt.Sprintf("%#v", this.Tolerations)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ResourceReqs) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vizierconfigpb.ResourceReqs{")
	if this.Limits != nil {
		s = append(s, "Limits: "+fmt.Sprintf("%#v", this.Limits)+",\n")
	}
	if this.Requests != nil {
		s = append(s, "Requests: "+fmt.Sprintf("%#v", this.Requests)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Toleration) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&vizierconfigpb.Toleration{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "Operator: "+fmt.Sprintf("%#v", this.Operator)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "Effect: "+fmt.Sprintf("%#v", this.Effect)+",\n")
	if this.TolerationSeconds != nil {
		s = append(s, "TolerationSeconds: "+fmt.Sprintf("%#v", this.TolerationSeconds)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ResourceList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierconfigpb.ResourceList{")
	keysForResourceList := make([]string, 0, len(this.ResourceList))
	for k, _ := range this.ResourceList {
		keysForResourceList = append(keysForResourceList, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForResourceList)
	mapStringForResourceList := "map[string]*ResourceQuantity{"
	for _, k := range keysForResourceList {
		mapStringForResourceList += fmt.Sprintf("%#v: %#v,", k, this.ResourceList[k])
	}
	mapStringForResourceList += "}"
	if this.ResourceList != nil {
		s = append(s, "ResourceList: "+mapStringForResourceList+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ResourceQuantity) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierconfigpb.ResourceQuantity{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DataCollectorParams) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vizierconfigpb.DataCollectorParams{")
	s = append(s, "DatastreamBufferSize: "+fmt.Sprintf("%#v", this.DatastreamBufferSize)+",\n")
	s = append(s, "DatastreamBufferSpikeSize: "+fmt.Sprintf("%#v", this.DatastreamBufferSpikeSize)+",\n")
	keysForCustomPEMFlags := make([]string, 0, len(this.CustomPEMFlags))
	for k, _ := range this.CustomPEMFlags {
		keysForCustomPEMFlags = append(keysForCustomPEMFlags, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForCustomPEMFlags)
	mapStringForCustomPEMFlags := "map[string]string{"
	for _, k := range keysForCustomPEMFlags {
		mapStringForCustomPEMFlags += fmt.Sprintf("%#v: %#v,", k, this.CustomPEMFlags[k])
	}
	mapStringForCustomPEMFlags += "}"
	if this.CustomPEMFlags != nil {
		s = append(s, "CustomPEMFlags: "+mapStringForCustomPEMFlags+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LeadershipElectionParams) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierconfigpb.LeadershipElectionParams{")
	s = append(s, "ElectionPeriodMs: "+fmt.Sprintf("%#v", this.ElectionPeriodMs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringVizierTypes(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *VizierSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *VizierSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Autopilot {
		i--
		if m.Autopilot {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if len(m.Registry) > 0 {
		i -= len(m.Registry)
		copy(dAtA[i:], m.Registry)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.Registry)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if len(m.PemMemoryRequest) > 0 {
		i -= len(m.PemMemoryRequest)
		copy(dAtA[i:], m.PemMemoryRequest)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.PemMemoryRequest)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if len(m.CustomDeployKeySecret) > 0 {
		i -= len(m.CustomDeployKeySecret)
		copy(dAtA[i:], m.CustomDeployKeySecret)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.CustomDeployKeySecret)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if m.LeadershipElectionParams != nil {
		{
			size, err := m.LeadershipElectionParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if m.DataCollectorParams != nil {
		{
			size, err := m.DataCollectorParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	if len(m.DataAccess) > 0 {
		i -= len(m.DataAccess)
		copy(dAtA[i:], m.DataAccess)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.DataAccess)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.ClockConverter) > 0 {
		i -= len(m.ClockConverter)
		copy(dAtA[i:], m.ClockConverter)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.ClockConverter)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.Patches) > 0 {
		for k := range m.Patches {
			v := m.Patches[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintVizierTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if m.Pod_Policy != nil {
		{
			size, err := m.Pod_Policy.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if len(m.PemMemoryLimit) > 0 {
		i -= len(m.PemMemoryLimit)
		copy(dAtA[i:], m.PemMemoryLimit)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.PemMemoryLimit)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.DevCloudNamespace) > 0 {
		i -= len(m.DevCloudNamespace)
		copy(dAtA[i:], m.DevCloudNamespace)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.DevCloudNamespace)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.CloudAddr) > 0 {
		i -= len(m.CloudAddr)
		copy(dAtA[i:], m.CloudAddr)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.CloudAddr)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.ClusterName) > 0 {
		i -= len(m.ClusterName)
		copy(dAtA[i:], m.ClusterName)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.ClusterName)))
		i--
		dAtA[i] = 0x2a
	}
	if m.UseEtcdOperator {
		i--
		if m.UseEtcdOperator {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.DisableAutoUpdate {
		i--
		if m.DisableAutoUpdate {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.DeployKey) > 0 {
		i -= len(m.DeployKey)
		copy(dAtA[i:], m.DeployKey)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.DeployKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PodPolicyReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PodPolicyReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PodPolicyReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Tolerations) > 0 {
		for iNdEx := len(m.Tolerations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tolerations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.NodeSelector) > 0 {
		for k := range m.NodeSelector {
			v := m.NodeSelector[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintVizierTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Resources != nil {
		{
			size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Annotations) > 0 {
		for k := range m.Annotations {
			v := m.Annotations[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintVizierTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Labels) > 0 {
		for k := range m.Labels {
			v := m.Labels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintVizierTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ResourceReqs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceReqs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceReqs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Requests != nil {
		{
			size, err := m.Requests.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Limits != nil {
		{
			size, err := m.Limits.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Toleration) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Toleration) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Toleration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TolerationSeconds != nil {
		{
			size, err := m.TolerationSeconds.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Effect) > 0 {
		i -= len(m.Effect)
		copy(dAtA[i:], m.Effect)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.Effect)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Operator) > 0 {
		i -= len(m.Operator)
		copy(dAtA[i:], m.Operator)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.Operator)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ResourceList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ResourceList) > 0 {
		for k := range m.ResourceList {
			v := m.ResourceList[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintVizierTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintVizierTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ResourceQuantity) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceQuantity) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceQuantity) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintVizierTypes(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DataCollectorParams) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DataCollectorParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DataCollectorParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CustomPEMFlags) > 0 {
		for k := range m.CustomPEMFlags {
			v := m.CustomPEMFlags[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintVizierTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintVizierTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.DatastreamBufferSpikeSize != 0 {
		i = encodeVarintVizierTypes(dAtA, i, uint64(m.DatastreamBufferSpikeSize))
		i--
		dAtA[i] = 0x10
	}
	if m.DatastreamBufferSize != 0 {
		i = encodeVarintVizierTypes(dAtA, i, uint64(m.DatastreamBufferSize))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *LeadershipElectionParams) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LeadershipElectionParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LeadershipElectionParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ElectionPeriodMs != 0 {
		i = encodeVarintVizierTypes(dAtA, i, uint64(m.ElectionPeriodMs))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintVizierTypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovVizierTypes(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *VizierSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.DeployKey)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	if m.DisableAutoUpdate {
		n += 2
	}
	if m.UseEtcdOperator {
		n += 2
	}
	l = len(m.ClusterName)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.CloudAddr)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.DevCloudNamespace)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.PemMemoryLimit)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	if m.Pod_Policy != nil {
		l = m.Pod_Policy.Size()
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	if len(m.Patches) > 0 {
		for k, v := range m.Patches {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovVizierTypes(uint64(len(k))) + 1 + len(v) + sovVizierTypes(uint64(len(v)))
			n += mapEntrySize + 1 + sovVizierTypes(uint64(mapEntrySize))
		}
	}
	l = len(m.ClockConverter)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.DataAccess)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	if m.DataCollectorParams != nil {
		l = m.DataCollectorParams.Size()
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	if m.LeadershipElectionParams != nil {
		l = m.LeadershipElectionParams.Size()
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.CustomDeployKeySecret)
	if l > 0 {
		n += 2 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.PemMemoryRequest)
	if l > 0 {
		n += 2 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.Registry)
	if l > 0 {
		n += 2 + l + sovVizierTypes(uint64(l))
	}
	if m.Autopilot {
		n += 3
	}
	return n
}

func (m *PodPolicyReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovVizierTypes(uint64(len(k))) + 1 + len(v) + sovVizierTypes(uint64(len(v)))
			n += mapEntrySize + 1 + sovVizierTypes(uint64(mapEntrySize))
		}
	}
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovVizierTypes(uint64(len(k))) + 1 + len(v) + sovVizierTypes(uint64(len(v)))
			n += mapEntrySize + 1 + sovVizierTypes(uint64(mapEntrySize))
		}
	}
	if m.Resources != nil {
		l = m.Resources.Size()
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	if len(m.NodeSelector) > 0 {
		for k, v := range m.NodeSelector {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovVizierTypes(uint64(len(k))) + 1 + len(v) + sovVizierTypes(uint64(len(v)))
			n += mapEntrySize + 1 + sovVizierTypes(uint64(mapEntrySize))
		}
	}
	if len(m.Tolerations) > 0 {
		for _, e := range m.Tolerations {
			l = e.Size()
			n += 1 + l + sovVizierTypes(uint64(l))
		}
	}
	return n
}

func (m *ResourceReqs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Limits != nil {
		l = m.Limits.Size()
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	if m.Requests != nil {
		l = m.Requests.Size()
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	return n
}

func (m *Toleration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.Operator)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	l = len(m.Effect)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	if m.TolerationSeconds != nil {
		l = m.TolerationSeconds.Size()
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	return n
}

func (m *ResourceList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ResourceList) > 0 {
		for k, v := range m.ResourceList {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovVizierTypes(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovVizierTypes(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovVizierTypes(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ResourceQuantity) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovVizierTypes(uint64(l))
	}
	return n
}

func (m *DataCollectorParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DatastreamBufferSize != 0 {
		n += 1 + sovVizierTypes(uint64(m.DatastreamBufferSize))
	}
	if m.DatastreamBufferSpikeSize != 0 {
		n += 1 + sovVizierTypes(uint64(m.DatastreamBufferSpikeSize))
	}
	if len(m.CustomPEMFlags) > 0 {
		for k, v := range m.CustomPEMFlags {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovVizierTypes(uint64(len(k))) + 1 + len(v) + sovVizierTypes(uint64(len(v)))
			n += mapEntrySize + 1 + sovVizierTypes(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *LeadershipElectionParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ElectionPeriodMs != 0 {
		n += 1 + sovVizierTypes(uint64(m.ElectionPeriodMs))
	}
	return n
}

func sovVizierTypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozVizierTypes(x uint64) (n int) {
	return sovVizierTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *VizierSpec) String() string {
	if this == nil {
		return "nil"
	}
	keysForPatches := make([]string, 0, len(this.Patches))
	for k, _ := range this.Patches {
		keysForPatches = append(keysForPatches, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForPatches)
	mapStringForPatches := "map[string]string{"
	for _, k := range keysForPatches {
		mapStringForPatches += fmt.Sprintf("%v: %v,", k, this.Patches[k])
	}
	mapStringForPatches += "}"
	s := strings.Join([]string{`&VizierSpec{`,
		`Version:` + fmt.Sprintf("%v", this.Version) + `,`,
		`DeployKey:` + fmt.Sprintf("%v", this.DeployKey) + `,`,
		`DisableAutoUpdate:` + fmt.Sprintf("%v", this.DisableAutoUpdate) + `,`,
		`UseEtcdOperator:` + fmt.Sprintf("%v", this.UseEtcdOperator) + `,`,
		`ClusterName:` + fmt.Sprintf("%v", this.ClusterName) + `,`,
		`CloudAddr:` + fmt.Sprintf("%v", this.CloudAddr) + `,`,
		`DevCloudNamespace:` + fmt.Sprintf("%v", this.DevCloudNamespace) + `,`,
		`PemMemoryLimit:` + fmt.Sprintf("%v", this.PemMemoryLimit) + `,`,
		`Pod_Policy:` + strings.Replace(this.Pod_Policy.String(), "PodPolicyReq", "PodPolicyReq", 1) + `,`,
		`Patches:` + mapStringForPatches + `,`,
		`ClockConverter:` + fmt.Sprintf("%v", this.ClockConverter) + `,`,
		`DataAccess:` + fmt.Sprintf("%v", this.DataAccess) + `,`,
		`DataCollectorParams:` + strings.Replace(this.DataCollectorParams.String(), "DataCollectorParams", "DataCollectorParams", 1) + `,`,
		`LeadershipElectionParams:` + strings.Replace(this.LeadershipElectionParams.String(), "LeadershipElectionParams", "LeadershipElectionParams", 1) + `,`,
		`CustomDeployKeySecret:` + fmt.Sprintf("%v", this.CustomDeployKeySecret) + `,`,
		`PemMemoryRequest:` + fmt.Sprintf("%v", this.PemMemoryRequest) + `,`,
		`Registry:` + fmt.Sprintf("%v", this.Registry) + `,`,
		`Autopilot:` + fmt.Sprintf("%v", this.Autopilot) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PodPolicyReq) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTolerations := "[]*Toleration{"
	for _, f := range this.Tolerations {
		repeatedStringForTolerations += strings.Replace(f.String(), "Toleration", "Toleration", 1) + ","
	}
	repeatedStringForTolerations += "}"
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	keysForAnnotations := make([]string, 0, len(this.Annotations))
	for k, _ := range this.Annotations {
		keysForAnnotations = append(keysForAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
	mapStringForAnnotations := "map[string]string{"
	for _, k := range keysForAnnotations {
		mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k])
	}
	mapStringForAnnotations += "}"
	keysForNodeSelector := make([]string, 0, len(this.NodeSelector))
	for k, _ := range this.NodeSelector {
		keysForNodeSelector = append(keysForNodeSelector, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
	mapStringForNodeSelector := "map[string]string{"
	for _, k := range keysForNodeSelector {
		mapStringForNodeSelector += fmt.Sprintf("%v: %v,", k, this.NodeSelector[k])
	}
	mapStringForNodeSelector += "}"
	s := strings.Join([]string{`&PodPolicyReq{`,
		`Labels:` + mapStringForLabels + `,`,
		`Annotations:` + mapStringForAnnotations + `,`,
		`Resources:` + strings.Replace(this.Resources.String(), "ResourceReqs", "ResourceReqs", 1) + `,`,
		`NodeSelector:` + mapStringForNodeSelector + `,`,
		`Tolerations:` + repeatedStringForTolerations + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceReqs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceReqs{`,
		`Limits:` + strings.Replace(this.Limits.String(), "ResourceList", "ResourceList", 1) + `,`,
		`Requests:` + strings.Replace(this.Requests.String(), "ResourceList", "ResourceList", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Toleration) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Toleration{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Operator:` + fmt.Sprintf("%v", this.Operator) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`Effect:` + fmt.Sprintf("%v", this.Effect) + `,`,
		`TolerationSeconds:` + strings.Replace(fmt.Sprintf("%v", this.TolerationSeconds), "Int64Value", "types.Int64Value", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceList) String() string {
	if this == nil {
		return "nil"
	}
	keysForResourceList := make([]string, 0, len(this.ResourceList))
	for k, _ := range this.ResourceList {
		keysForResourceList = append(keysForResourceList, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForResourceList)
	mapStringForResourceList := "map[string]*ResourceQuantity{"
	for _, k := range keysForResourceList {
		mapStringForResourceList += fmt.Sprintf("%v: %v,", k, this.ResourceList[k])
	}
	mapStringForResourceList += "}"
	s := strings.Join([]string{`&ResourceList{`,
		`ResourceList:` + mapStringForResourceList + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceQuantity) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceQuantity{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DataCollectorParams) String() string {
	if this == nil {
		return "nil"
	}
	keysForCustomPEMFlags := make([]string, 0, len(this.CustomPEMFlags))
	for k, _ := range this.CustomPEMFlags {
		keysForCustomPEMFlags = append(keysForCustomPEMFlags, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForCustomPEMFlags)
	mapStringForCustomPEMFlags := "map[string]string{"
	for _, k := range keysForCustomPEMFlags {
		mapStringForCustomPEMFlags += fmt.Sprintf("%v: %v,", k, this.CustomPEMFlags[k])
	}
	mapStringForCustomPEMFlags += "}"
	s := strings.Join([]string{`&DataCollectorParams{`,
		`DatastreamBufferSize:` + fmt.Sprintf("%v", this.DatastreamBufferSize) + `,`,
		`DatastreamBufferSpikeSize:` + fmt.Sprintf("%v", this.DatastreamBufferSpikeSize) + `,`,
		`CustomPEMFlags:` + mapStringForCustomPEMFlags + `,`,
		`}`,
	}, "")
	return s
}
func (this *LeadershipElectionParams) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LeadershipElectionParams{`,
		`ElectionPeriodMs:` + fmt.Sprintf("%v", this.ElectionPeriodMs) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringVizierTypes(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *VizierSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierTypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: VizierSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VizierSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeployKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeployKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisableAutoUpdate", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisableAutoUpdate = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseEtcdOperator", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseEtcdOperator = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloudAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CloudAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevCloudNamespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevCloudNamespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PemMemoryLimit", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PemMemoryLimit = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pod_Policy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pod_Policy == nil {
				m.Pod_Policy = &PodPolicyReq{}
			}
			if err := m.Pod_Policy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Patches", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Patches == nil {
				m.Patches = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipVizierTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Patches[mapkey] = mapvalue
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClockConverter", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClockConverter = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataAccess", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DataAccess = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataCollectorParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DataCollectorParams == nil {
				m.DataCollectorParams = &DataCollectorParams{}
			}
			if err := m.DataCollectorParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LeadershipElectionParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LeadershipElectionParams == nil {
				m.LeadershipElectionParams = &LeadershipElectionParams{}
			}
			if err := m.LeadershipElectionParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomDeployKeySecret", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CustomDeployKeySecret = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PemMemoryRequest", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PemMemoryRequest = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Registry", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Registry = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Autopilot", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Autopilot = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipVizierTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PodPolicyReq) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierTypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PodPolicyReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodPolicyReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipVizierTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Annotations == nil {
				m.Annotations = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipVizierTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Annotations[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Resources == nil {
				m.Resources = &ResourceReqs{}
			}
			if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeSelector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NodeSelector == nil {
				m.NodeSelector = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipVizierTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.NodeSelector[mapkey] = mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tolerations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tolerations = append(m.Tolerations, &Toleration{})
			if err := m.Tolerations[len(m.Tolerations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResourceReqs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierTypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceReqs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceReqs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limits", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Limits == nil {
				m.Limits = &ResourceList{}
			}
			if err := m.Limits.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Requests == nil {
				m.Requests = &ResourceList{}
			}
			if err := m.Requests.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Toleration) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierTypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Toleration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Toleration: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Operator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Effect", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Effect = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TolerationSeconds", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TolerationSeconds == nil {
				m.TolerationSeconds = &types.Int64Value{}
			}
			if err := m.TolerationSeconds.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResourceList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierTypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ResourceList == nil {
				m.ResourceList = make(map[string]*ResourceQuantity)
			}
			var mapkey string
			var mapvalue *ResourceQuantity
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ResourceQuantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipVizierTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ResourceList[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResourceQuantity) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierTypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceQuantity: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceQuantity: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DataCollectorParams) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierTypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DataCollectorParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DataCollectorParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatastreamBufferSize", wireType)
			}
			m.DatastreamBufferSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DatastreamBufferSize |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatastreamBufferSpikeSize", wireType)
			}
			m.DatastreamBufferSpikeSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DatastreamBufferSpikeSize |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomPEMFlags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CustomPEMFlags == nil {
				m.CustomPEMFlags = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthVizierTypes
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipVizierTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthVizierTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.CustomPEMFlags[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LeadershipElectionParams) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierTypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LeadershipElectionParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LeadershipElectionParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ElectionPeriodMs", wireType)
			}
			m.ElectionPeriodMs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ElectionPeriodMs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipVizierTypes(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowVizierTypes
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowVizierTypes
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthVizierTypes
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupVizierTypes
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthVizierTypes
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthVizierTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowVizierTypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupVizierTypes = fmt.Errorf("proto: unexpected end of group")
)
